function allItemDoTask(arr, task) {
    for (var i = 0; i < arr.length; i++) {
        var item = arr[i];
        task(item);
    }
}

/* 
allItemDoTask2(
    [
        {"arr":arr1,"task":task1},
        {"arr":arr2,"task":task2},
    ]
)
*/
function allItemDoTask2(arrs, task) {
    for (var i = 0; i < arrs.length; i++) {
        var obj = arrs[i];
        var arr = obj.arr;
        var task = obj.task;

        for (var j = 0; j < arr.length; j++) {
            var item = arr[j];
            task(item);
        }
    }
}

/* 伪数组转真数组 pseudo array */
function toArray(pArr) {
    var arr = [];
    for (var i = 0; i < pArr.length; i++) {
        arr.push(pArr[i]);
    }
    return arr;
}

/* 按格式打印数组 */
function logArr(arr, attrName) {
    var str = "[";
    arr.forEach(function (item) {
        str += item[attrName] + ",";
    });
    str += "]";
    console.log(str);
}

function getRandomItem(arr){
    return arr[Math.floor(Math.random()*arr.length)]
}

/* 为数组扩展去重方法 返回一个去重后的新数组 */
Array.prototype.norepeat = function () {
    console.log(this, "据说我能去重...");

    const newArr = [];
    this.forEach(function (item) {
        if (newArr.indexOf(item) === -1) {
            newArr.push(item);
        }
    });
    return newArr;
};

// ·扩展Array的方法，实现统计功能：
// ·const ret = arr.countRepeat() 返回结果{3:2,1:3,5:2}
Array.prototype.countRepeat = function () {
    const retObj = {};
    this.forEach(function (item) {
        if (!retObj.hasOwnProperty(item)) {
            retObj[item] = 1;
        } else {
            retObj[item]++;
        }
    });
    return retObj;
};

/**
 * 将item按照arr的原有排序插入到arr
 * @param {Array} arr 一个事先排好序的数组
 * @param {any} item 待插入的项目
 */
function insertByOrder(arr, ...items) {
    items.forEach(function (item) {
        arr.push(item);
        arr.sort(function (a, b) {
            if (arr[arr.length - 2] >= arr[0]) {
                return a >= b ? 1 : -1;
            } else {
                return a <= b ? 1 : -1;
            }
        });
    });

    return arr;
}

/**
 * 选择排序
 * @param {Array} arr 要排序的数组
 * @returns 排好序的数组（原地排序）
 */
function selectSort(arr, useAsc = true) {
    // var arr = [3, 6, 4, 5, 9, 2, 1, 8, 7, 0]

    // 外层循环依次锁定0~8号位
    // 每锁定一位 就要将该位以后最小的值 与该位当前值互换位置
    for (var si = 0; si < arr.length - 1; si++) {
        // 假设最小的值是0号位的值 最小值出现的位置为0
        var minValue = arr[si],
            minIndex = si;

        /* 将[0,末位]内的值进行遍历 将最小的值及其位置记录下来 */
        for (var i = si; i < arr.length; i++) {
            var value = arr[i];

            // 如果当前位的值小于minValue 则记录最新的最小值及其位置
            if ((useAsc && value < minValue) || (!useAsc && value > minValue)) {
                // 更新最小值与最小值位置
                minValue = value;
                minIndex = i;
            }
        }

        /* 将0号位与最小位进行位置互换 */
        var temp;
        temp = arr[si];
        arr[si] = minValue;
        arr[minIndex] = temp;
    }

    // console.log(arr);
    // return useAsc ? arr : arr.reverse();
    return arr;
}

/**
 * 冒泡排序
 * @param {Array} arr 要排序的数组
 * @returns 排好序的数组（原地排序）
 */
function bubbleSort(arr, useAsc = true) {
    // var arr = [3, 6, 4, 5, 9, 2, 1, 8, 7, 0]

    /* 第一轮冒泡 最大的调节（相邻的元素做两两比较 大的往后调）至末位 */
    var temp;

    for (var j = 1; j < arr.length; j++) {
        for (var i = 0; i < arr.length - j; i++) {
            // i位与i+1位比 大的去i+1位
            if (useAsc ? arr[i + 1] < arr[i] : arr[i + 1] > arr[i]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
    }

    // console.log(arr);
    return arr;
}
